package 集合;

//在编写应用程序的时候，经常需要读写配置文件。例如，用户的设置：
//
//# 上次最后打开的文件:
//last_open_file=/data/hello.txt
//# 自动保存文件的时间间隔:
//auto_save_interval=60
//
//配置文件的特点是，它的Key-Value一般都是String-String类型的，因此我们完全可以用Map<String, String>来表示它。
//因为配置文件非常常用，所以Java集合库提供了一个Properties来表示一组“配置”。由于历史遗留原因，Properties内部本质上是一个Hashtable，但我们
//只需要用到Properties自身关于读写配置的接口。
//
//《读取配置文件》
//用Properties读取配置文件非常简单。Java默认配置文件以.properties为扩展名，每行以key=value表示，以#课开头的是注释。以下是一个典型的配置文件：
//
//# setting.properties
//
//last_open_file=/data/hello.txt
//auto_save_interval=60
//可以从文件系统读取这个.properties文件：
//
//String f = "setting.properties";
//Properties props = new Properties();
//props.load(new java.io.FileInputStream(f));
//
//String filepath = props.getProperty("last_open_file");
//String interval = props.getProperty("auto_save_interval", "120");
//可见，用Properties读取配置文件，一共有三步：
//
//1.创建Properties实例；
//2.调用load()读取文件；
//3.调用getProperty()获取配置。
//
//调用getProperty()获取配置时，如果key不存在，将返回null。我们还可以提供一个默认值，这样，当key不存在的时候，就返回默认值。
//
//也可以从classpath读取.properties文件，因为load(InputStream)方法接收一个InputStream实例，表示一个字节流，它不一定是文件流，也可以是从jar包
//中读取的资源流：
//
//Properties props = new Properties();
//props.load(getClass().getResourceAsStream("/common/setting.properties"));
//试试从内存读取一个字节流：

// properties
//import java.io.*;
//import java.util.Properties;
//
//public class 使用Properties {
//    public static void main(String[] args) throws IOException {
//        String settings = "# test" + "\n" + "course=Java" + "\n" + "last_open_date=2019-08-07T12:35:01"+"\n" + "auto_save=120";
//        ByteArrayInputStream input = new ByteArrayInputStream(settings.getBytes("UTF-8"));
//        Properties props = new Properties();
//        props.load(input);
//
//        System.out.println("course: " + props.getProperty("course"));
//        System.out.println("last_open_date: " + props.getProperty("last_open_date"));
//        System.out.println("last_open_file: " + props.getProperty("last_open_file"));
//        System.out.println("auto_save: " + props.getProperty("auto_save", "60"));//60为默认值
//    }
//}

//如果有多个.properties文件，可以反复调用load()读取，后读取的key-value会覆盖已读取的key-value：
//
//Properties props = new Properties();
//props.load(getClass().getResourceAsStream("/common/setting.properties"));
//props.load(new FileInputStream("C:\\conf\\setting.properties"));
//上面的代码演示了Properties的一个常用用法：可以把默认配置文件放到classpath中，然后，根据机器的环境编写另一个配置文件，覆盖某些默认的配置。
//
//Properties设计的目的是存储String类型的key－value，但Properties实际上是从Hashtable派生的，它的设计实际上是有问题的，但是为了保持兼容性，现在已经
//没法修改了。除了getProperty()和setProperty()方法外，还有从Hashtable继承下来的get()和put()方法，这些方法的参数签名是Object，我们在使
//用Properties的时候，不要去调用这些从Hashtable继承下来的方法。
//
//《写入配置文件》
//如果通过setProperty()修改了Properties实例，可以把配置写入文件，以便下次启动时获得最新配置。写入配置文件使用store()方法：
//
//Properties props = new Properties();
//props.setProperty("url", "http://www.liaoxuefeng.com");
//props.setProperty("language", "Java");
//props.store(new FileOutputStream("C:\\conf\\setting.properties"), "这是写入的properties注释");
//
//《编码》
//早期版本的Java规定.properties文件编码是ASCII编码（ISO8859-1），如果涉及到中文就必须用name=\u4e2d\u6587来表示，非常别扭。从JDK9开始，
//Java的.properties文件可以使用UTF-8编码了。
//
//不过，需要注意的是，由于load(InputStream)默认总是以ASCII编码读取字节流，所以会导致读到乱码。我们需要用另一个重载方法load(Reader)读取：
//
//Properties props = new Properties();
//props.load(new FileReader("settings.properties", StandardCharsets.UTF_8));
//就可以正常读取中文。InputStream和Reader的区别是一个是字节流，一个是字符流。字符流在内存中已经以char类型表示了，不涉及编码问题。
//
//《小结》
//Java集合库提供的Properties用于读写配置文件.properties。.properties文件可以使用UTF-8编码。
//可以从文件系统、classpath或其他任何地方读取.properties文件。
//读写Properties时，注意仅使用getProperty()和setProperty()方法，不要调用继承而来的get()和put()等方法。


import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Locale;
import java.util.Properties;
import java.util.PropertyResourceBundle;
import java.util.ResourceBundle;

//读取properties文件的方式

//public class LoadPropertiesFileUtil {
public class 使用Properties {

    private static String basePath = "src/main/java/cn/habitdiary/prop.properties";
    private static String path = "";

    //一、 使用java.util.Properties类的load(InputStream in)方法加载properties文件
    public static String getPath1() {

        try {
            InputStream in = new BufferedInputStream(new FileInputStream(
                    new File(basePath)));
            Properties prop = new Properties();

            prop.load(in);

            path = prop.getProperty("path");

        } catch (FileNotFoundException e) {
            System.out.println("properties文件路径书写有误，请检查！");
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return path;
    }

    //二、 使用java.util.ResourceBundle类的getBundle()方法
    //注意：这个getBundle()方法的参数只能写成包路径+properties文件名，否则将抛异常
    public static String getPath2() {
        ResourceBundle rb = ResourceBundle
                .getBundle("cn/habitdiary/prop");
        path = rb.getString("path");
        return path;
    }

    //三、 使用java.util.PropertyResourceBundle类的构造函数
    public static String getPath3() {
        InputStream in;
        try {
            in = new BufferedInputStream(new FileInputStream(basePath));
            ResourceBundle rb = new PropertyResourceBundle(in);
            path = rb.getString("path");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return path;
    }

    //四、 使用class变量的getResourceAsStream()方法
    //注意：getResourceAsStream()方法的参数按格式写到包路径+properties文件名+.后缀
    public static String getPath4() {
        InputStream in = 使用Properties.class
                .getResourceAsStream("cn/habitdiary/prop.properties");
        Properties p = new Properties();
        try {
            p.load(in);
            path = p.getProperty("path");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return path;
    }

    //五、
    //使用class.getClassLoader()所得到的java.lang.ClassLoader的
    //getResourceAsStream()方法
    //getResourceAsStream(name)方法的参数必须是包路径+文件名+.后缀
    //否则会报空指针异常
    public static String getPath5() {
        InputStream in = 使用Properties.class.getClassLoader()
                .getResourceAsStream("cn/habitdiary/prop.properties");
        Properties p = new Properties();
        try {
            p.load(in);
            path = p.getProperty("path");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return path;
    }

    //六、 使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法
    //getSystemResourceAsStream()方法的参数格式也是有固定要求的
    public static String getPath6() {
        InputStream in = ClassLoader
                .getSystemResourceAsStream("cn/habitdiary/prop.properties");
        Properties p = new Properties();
        try {
            p.load(in);
            path = p.getProperty("path");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return path;
    }

    public static void main(String[] args) {
        System.out.println(LoadPropertiesFileUtil.getPath1());
        System.out.println(LoadPropertiesFileUtil.getPath2());
        System.out.println(LoadPropertiesFileUtil.getPath3());
        System.out.println(LoadPropertiesFileUtil.getPath4());
        System.out.println(LoadPropertiesFileUtil.getPath5());
        System.out.println(LoadPropertiesFileUtil.getPath6());
    }
}
/*
其中第一、四、五、六种方式都是先获得文件的输入流，然后通过Properties类的load(InputStream inStream)方法加载到Properties对象中，最后通
过Properties对象来操作文件内容。
第二、三中方式是通过ResourceBundle类来加载Properties文件，然后ResourceBundle对象来操做properties文件内容。
其中最重要的就是每种方式加载文件时，文件的路径需要按照方法的定义的格式来加载，否则会抛出各种异常，比如空指针异常。

遍历
下面给出四种遍历Properties中的所有键值对的方法：

/**
 * 输出properties的key和value
 */
public static void printProp(Properties properties) {
    System.out.println("---------（方式一）------------");
    for (String key : properties.stringPropertyNames()) {
        System.out.println(key + "=" + properties.getProperty(key));
    }

    System.out.println("---------（方式二）------------");
    Set<Object> keys = properties.keySet();//返回属性key的集合
    for (Object key : keys) {
        System.out.println(key.toString() + "=" + properties.get(key));
    }

    System.out.println("---------（方式三）------------");
    Set<Map.Entry<Object, Object>> entrySet = properties.entrySet();
    //返回的属性键值对实体
    for (Map.Entry<Object, Object> entry : entrySet) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }

    System.out.println("---------（方式四）------------");
    Enumeration<?> e = properties.propertyNames();
    while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        String value = properties.getProperty(key);
        System.out.println(key + "=" + value);
    }
}


《一个比较综合的实例》:
根据key读取value,读取properties的全部信息,写入新的properties信息

//关于Properties类常用的操作
public class TestProperties {
    //根据Key读取Value
    public static String GetValueByKey(String filePath, String key) {
        Properties pps = new Properties();
        try {
            InputStream in = new BufferedInputStream (new FileInputStream(filePath));  
            pps.load(in);
            String value = pps.getProperty(key);
            System.out.println(key + " = " + value);
            return value;
            
        }catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    //读取Properties的全部信息
    public static void GetAllProperties(String filePath) throws IOException {
        Properties pps = new Properties();
        InputStream in = new BufferedInputStream(new FileInputStream(filePath));
        pps.load(in);
        Enumeration en = pps.propertyNames(); //得到配置文件的名字
        
        while(en.hasMoreElements()) {
            String strKey = (String) en.nextElement();
            String strValue = pps.getProperty(strKey);
            System.out.println(strKey + "=" + strValue);
        }
        
    }
    
    //写入Properties信息
    public static void WriteProperties (String filePath, String pKey, String pValue) throws IOException {
        Properties pps = new Properties();
        
        InputStream in = new FileInputStream(filePath);
        //从输入流中读取属性列表（键和元素对） 
        pps.load(in);
        //调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。  
        //强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
        OutputStream out = new FileOutputStream(filePath);
        pps.setProperty(pKey, pValue);
        //以适合使用 load 方法加载到 Properties 表中的格式，  
        //将此 Properties 表中的属性列表（键和元素对）写入输出流  
        pps.store(out, "Update " + pKey + " name");//写入以#号开始的注释文字和由setProperty设定的键-值对至out流
    }
    
    public static void main(String [] args) throws IOException{
        //String value = GetValueByKey("db.properties", "name");
        //System.out.println(value);
        //GetAllProperties("db.properties");
        WriteProperties("db.properties","long", "212");
    }
}
//结果：
//db.properties中文件的数据为：
//
//#Update long name
//#Sun Feb 23 18:17:16 CST 2014
//name=JJ
//Weight=4444
//long=212
//Height=3333


//《Java读取Properties》
//Java读取Properties文件的方法有很多，下面介绍8种方式，分别读取resource目录下的jdbc.properties和resource/config/application.properties。
//
//application.properties文件内容如下
//minio.endpoint=http://localhost:9000
//minio.accessKey=minioadmin
//minio.secretKey=minioadmin
//minio.bucketName=demo
//
//1. 从当前的类加载器的getResourcesAsStream来获取
///**
//     * 1. 方式一
//     * 从当前的类加载器的getResourcesAsStream来获取
//     * InputStream inputStream = this.getClass().getResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test1() throws IOException {
//        InputStream inputStream = this.getClass().getResourceAsStream("jdbc.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("jdbc.url");
//        System.out.println("property = " + property);
//    }
//
//2. 从当前的类加载器的getClassLoader().getResourcesAsStream来获取
// /**
//     * 2. 方式二
//     * 从当前的类加载器的getResourcesAsStream来获取
//     * InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test2() throws IOException {
//        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//3. 使用Class类的getSystemResourceAsStream静态方法 和使用当前类的ClassLoader是一样的
// /**
//     * 3. 方式三
//     * 使用Class类的getSystemResourceAsStream方法 和使用当前类的ClassLoader是一样的
//     * InputStream inputStream = ClassLoader.getSystemResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test3() throws IOException {
//        InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//4. 使用Spring-core包中的ClassPathResource读取
//    /**
//     * 4. 方式四
//     * Resource resource = new ClassPathResource(path)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test4() throws IOException {
//        Resource resource = new ClassPathResource("config/application.properties");
//        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//5. 从文件中读取，new BufferedInputStream(InputStream in)
///**
//     * 5. 方式五
//     * 从文件中获取,使用InputStream字节,主要是需要加上当前配置文件所在的项目src目录地址。路径配置需要精确到绝对地址级别
//     * BufferedInputStream继承自InputStream
//     * InputStream inputStream = new BufferedInputStream(new FileInputStream(name)
//     * 这种方法读取需要完整的路径，优点是可以读取任意路径下的文件，缺点是不太灵活
//     * @throws IOException
//     */
//    @Test
//    public void test5() throws IOException {
//        InputStream inputStream = new BufferedInputStream(new FileInputStream("src/main/resources/config/application.properties"));
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//6.从文件中读取，new FileInputStream(String name)
///**
//     * 6. 方式六
//     * 从文件中获取,使用InputStream字节,主要是需要加上当前配置文件所在的项目src目录地址。路径配置需要精确到绝对地址级别
//     * FileInputStream继承自InputStream
//     * InputStream inputStream = new FileInputStream(name)
//     * 这种方法读取需要完整的路径，优点是可以读取任意路径下的文件，缺点是不太灵活
//     * @throws IOException
//     */
//    @Test
//    public void test6() throws IOException {
//        InputStream inputStream = new FileInputStream("src/main/resources/config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//7. 使用PropertyResourceBundle读取InputStream流
// /**
//     * 7. 方式七
//     * 使用InputStream流来进行操作ResourceBundle，获取流的方式由以上几种。
//     * ResourceBundle resourceBundle = new PropertyResourceBundle(inputStream);
//     * @throws IOException
//     */
//    @Test
//    public void test7() throws IOException {
//        InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/application.properties");
//        ResourceBundle resourceBundle = new PropertyResourceBundle(inputStream);
//        Enumeration<String> keys = resourceBundle.getKeys();
//        while (keys.hasMoreElements()) {
//            String s = keys.nextElement();
//            System.out.println(s + " = " + resourceBundle.getString(s));
//        }
//    }
//
//8. 使用ResourceBundle.getBundle读取
// /**
//     * 8. 方式八
//     * ResourceBundle.getBundle的路径访问和 Class.getClassLoader.getResourceAsStream类似，默认从根目录下读取，也可以读取resources目录下的文件
//     * ResourceBundle rb = ResourceBundle.getBundle("b") //不需要指定文件名的后缀,只需要写文件名前缀即可
//     */
//    @Test
//    public void test8(){
//        //ResourceBundle rb = ResourceBundle.getBundle("jdbc"); //读取resources目录下的jdbc.properties
//        ResourceBundle rb2 = ResourceBundle.getBundle("config/application");//读取resources/config目录下的application.properties
//        for(String key : rb2.keySet()){
//            String value = rb2.getString(key);
//            System.out.println(key + ":" + value);
//        }
//
//    }
/*
输出结果：

minio.endpoint:http://localhost:9000
minio.bucketName:demo
minio.secretKey:minioadmin
minio.accessKey:minioadmin

六、Properties配合Spring框架使用
加载.properties方式一
<!-- 1.加载 jdbc.properties 配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties" system-properties-mode="NEVER"/>

除了上面这种方式之外，还有下面这种List集合的方式

加载.properties方式二
 <!-- 4.引入外部配置文件 由于后期可能会引入多个配置文件 所以采用list的形式 -->
    <bean id="propertyPlaceholder"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:/config/jdbc.properties</value>
                <value>classpath:/config/application.properties</value>
            </list>
        </property>
    </bean>


七、完整代码*/
//import org.junit.Test;
//import org.springframework.core.io.ClassPathResource;
//import org.springframework.core.io.Resource;
//import org.springframework.core.io.support.PropertiesLoaderUtils;
//import java.io.BufferedInputStream;
//import java.io.FileInputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.util.*;
//
///**
// * @desc: Properties读取配置文件属性值的方式
// * @author: cao_wencao
// * @date: 2020-12-29 10:08
// */
//public class PropertiesTest {
//
//    /**
//     * 1. 方式一
//     * 从当前的类加载器的getResourcesAsStream来获取
//     * InputStream inputStream = this.getClass().getResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test1() throws IOException {
//        InputStream inputStream = this.getClass().getResourceAsStream("jdbc.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("jdbc.url");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 2. 方式二
//     * 从当前的类加载器的getResourcesAsStream来获取
//     * InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test5() throws IOException {
//        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 3. 方式三
//     * 使用Class类的getSystemResourceAsStream方法 和使用当前类的ClassLoader是一样的
//     * InputStream inputStream = ClassLoader.getSystemResourceAsStream(name)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test4() throws IOException {
//        InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 4. 方式四
//     * Resource resource = new ClassPathResource(path)
//     *
//     * @throws IOException
//     */
//    @Test
//    public void test2() throws IOException {
//        Resource resource = new ClassPathResource("config/application.properties");
//        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 5. 方式五
//     * 从文件中获取,使用InputStream字节,主要是需要加上当前配置文件所在的项目src目录地址。路径配置需要精确到绝对地址级别
//     * BufferedInputStream继承自InputStream
//     * InputStream inputStream = new BufferedInputStream(new FileInputStream(name)
//     * 这种方法读取需要完整的路径，优点是可以读取任意路径下的文件，缺点是不太灵活
//     * @throws IOException
//     */
//    @Test
//    public void test3() throws IOException {
//        InputStream inputStream = new BufferedInputStream(new FileInputStream("src/main/resources/config/application.properties"));
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 6. 方式六
//     * 从文件中获取,使用InputStream字节,主要是需要加上当前配置文件所在的项目src目录地址。路径配置需要精确到绝对地址级别
//     * FileInputStream继承自InputStream
//     * InputStream inputStream = new FileInputStream(name)
//     * 这种方法读取需要完整的路径，优点是可以读取任意路径下的文件，缺点是不太灵活
//     * @throws IOException
//     */
//    @Test
//    public void test6() throws IOException {
//        InputStream inputStream = new FileInputStream("src/main/resources/config/application.properties");
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        properties.list(System.out);
//        System.out.println("==============================================");
//        String property = properties.getProperty("minio.endpoint");
//        System.out.println("property = " + property);
//    }
//
//    /**
//     * 7. 方式七
//     * 使用InputStream流来进行操作ResourceBundle，获取流的方式由以上几种。
//     * ResourceBundle resourceBundle = new PropertyResourceBundle(inputStream);
//     * @throws IOException
//     */
//    @Test
//    public void test7() throws IOException {
//        InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/application.properties");
//        ResourceBundle resourceBundle = new PropertyResourceBundle(inputStream);
//        Enumeration<String> keys = resourceBundle.getKeys();
//        while (keys.hasMoreElements()) {
//            String s = keys.nextElement();
//            System.out.println(s + " = " + resourceBundle.getString(s));
//        }
//    }
//
//    /**
//     * 8. 方式八
//     * ResourceBundle.getBundle的路径访问和 Class.getClassLoader.getResourceAsStream类似，默认从根目录下读取，也可以读取resources目录下的文件
//     * ResourceBundle rb = ResourceBundle.getBundle("b") //不需要指定文件名的后缀,只需要写文件名前缀即可
//     */
//    @Test
//    public void test8(){
//        //ResourceBundle rb = ResourceBundle.getBundle("jdbc"); //读取resources目录下的jdbc.properties
//        ResourceBundle rb2 = ResourceBundle.getBundle("config/application");//读取resources/config目录下的application.properties
//        for(String key : rb2.keySet()){
//            String value = rb2.getString(key);
//            System.out.println(key + ":" + value);
//        }
//
//    }
//
//
//
//    /**
//     * 单独抽取的方法，用户检测能否正确操纵Properties
//     *
//     * @param inputStream
//     * @throws IOException
//     */
//    private void printKeyValue(InputStream inputStream) throws IOException {
//        Properties properties = new Properties();
//        properties.load(inputStream);
//        Set<Object> keys = properties.keySet();
//        for (Object key : keys) {
//            System.out.println(key + " = " + properties.get(key));
//        }
//    }
//}



